#include <vcl.h>
#include <Registry.hpp>
#include <IniFiles.hpp>
#pragma hdrstop

#include <Eic.h>
#include "uParamCourrierEtCarnAdr.h" //Pour GetRepsCourrier
#include "CAdresse.h"

#pragma package(smart_init)

#define MODULE_TAG 2549
//---------------------------------------------------------------------------
// ValidCtrCheck est utilisé est utilisé pour être sûr que les composants créés n'ont
// aucune fonction virtuelle pure.
//
static inline void ValidCtrCheck(CAdrPanel *)
{
  new CAdrPanel(NULL);
}

//---------------------------------------------------------------------------
namespace Cadresse
{
  void __fastcall PACKAGE Register()
  {
     TComponentClass classes[1] = {__classid(CAdrPanel)};
     RegisterComponents("EIC Ctrlstd", classes, 0);
  }
}

/*******************************************************************************

Fonction :

Paramétres d'entrée :

Paramétres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall VoirCarnetAdresses()
{
HINSTANCE hCarnAdr = NULL;
TFctGereCarnet _FctGereCarnet = NULL;
AnsiString aRepDll = "";
sConfigCarnAdr sConfig;
try
   {
   GetRepsCarnAdr(&aRepDll, NULL);
   aRepDll = aRepDll + "CarnAdr.dll";
   hCarnAdr = LoadLibrary (aRepDll.c_str());
   if (!hCarnAdr)
       throw EAbort("Impossible de charger "+ aRepDll);

   if (!_FctGereCarnet)
      {
      _FctGereCarnet = (TFctGereCarnet) GetProcAddress(hCarnAdr, "_GereCarnet");
      if (!_FctGereCarnet)
          throw EAbort("Impossible de charger la fonction _GereCarnet");
      }

   sConfig.ChoixSelection = eSansSelection;
   sConfig.aCategorieParDefaut = EmptyStr;
   sConfig.aCategoriesVisibles = EmptyStr;

   _FctGereCarnet(sConfig, NULL);

   FreeLibrary(hCarnAdr);
   }
catch(Exception &e)
   {
   EICDisplayException(TAGL,e);
   }
}

/*******************************************************************************
Fonction : Affiche une boite de dialogue permettant la sélection d'une fiche

Paramètres d'entrée : lCodeCarnDefaut : Fiche à sélectionner par défaut
                      aCategoriesAAfficher : Liste de catégories sélectionnables (au format SDF)
                                             séparées par des virgules. Si vide, toutes les
                                             catégories sont visibles.
                      aCategorieParDefaut : Catégorie sélectionnée par défaut;

Valeur retournée :
*******************************************************************************/
unsigned long  __fastcall SelectUneFiche (unsigned long lCodeCarnDefaut,
                                          const AnsiString &aCategoriesAAfficher,
                                          const AnsiString &aCategorieParDefaut
                                          )
{
HINSTANCE hCarnAdr = NULL;
TFctGereCarnet _FctGereCarnet = NULL;
AnsiString aRepDll;
sConfigCarnAdr sConfig;
TList *lstFiches = NULL;
unsigned long ulFicheChoisie = 0;
try
   {
   GetRepsCarnAdr(&aRepDll, NULL);
   aRepDll = aRepDll + "CarnAdr.dll";
   hCarnAdr = LoadLibrary (aRepDll.c_str());
   if (!hCarnAdr)
       throw EAbort("Impossible de charger "+ aRepDll);

   if (!_FctGereCarnet)
      {
      _FctGereCarnet = (TFctGereCarnet) GetProcAddress(hCarnAdr, "_GereCarnet");
      if (!_FctGereCarnet)
          throw EAbort("Impossible de charger la fonction _GereCarnet");
      }

   lstFiches = new TList;

   sConfig.ChoixSelection = eSelectionSimple;
   sConfig.slCodeCarnDefaut->Add(lCodeCarnDefaut);
   sConfig.aCategorieParDefaut = aCategorieParDefaut;
   sConfig.aCategoriesVisibles = aCategoriesAAfficher;

   _FctGereCarnet(sConfig, lstFiches);

   ulFicheChoisie = (lstFiches->Count == 0 ? 0 :(unsigned long)lstFiches->Items[0]);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(2), e);
   }
delete lstFiches;        lstFiches = NULL;
FreeLibrary(hCarnAdr);   hCarnAdr = NULL;

return ulFicheChoisie;
}

/*******************************************************************************
              CLASSE  CAdrRecherche
*******************************************************************************/
__fastcall CAdrRecherche::CAdrRecherche()
{
hCarnAdr            = NULL;
_ChercherFiche      = NULL;
ulNumFicheResult    = 0;
ulNumFiche          = 0;
slResult            = new TStringList();
}

__fastcall CAdrRecherche::~CAdrRecherche()
{
FreeLibrary(hCarnAdr);
delete slResult;       slResult = NULL;
}
/*******************************************************************************

Fonction :

P.E :

P.E modifiés :

P.S :
*******************************************************************************/
//Recherche d'une fiche dans la base
unsigned long __fastcall CAdrRecherche::DebutRecherche(short shRecherche)
{
AnsiString aRepDll;
try {
    if (!hCarnAdr)
       {
       GetRepsCarnAdr(&aRepDll, NULL);
       aRepDll = aRepDll + "CarnAdr.dll";
       hCarnAdr = LoadLibrary (aRepDll.c_str());
       if (!hCarnAdr)
           throw EAbort("Impossible de charger "+ aRepDll);
       }

    if (!_ChercherFiche) {
        _ChercherFiche = (FctChercherFiche) GetProcAddress(hCarnAdr, "_ChercherFiche");
        if (!_ChercherFiche)
            throw EAbort("Impossible de charger la fonction _ChercherFiche");
    }


    //Lance la recherche et recup le num de la fiche
    if (_ChercherFiche(shRecherche,
                       ulNumFiche,
                       aSociete.c_str(),
                       aCategorie.c_str(),
                       aNom.c_str(),
                       aPrenom.c_str(),
                       slResult))
       ulNumFicheResult = StrToInt(slResult->Strings[0]);
    else
       ulNumFicheResult = 0;

    } catch( Exception &e ) {
        EICDisplayException( TAG(20), e );
        return 0;
    }
return ulNumFicheResult;
}

//---------------------------------------------------------------------------
// Une recherche a dû être faite précédemment
// La recherche du suivant se fait d'après la même clé
unsigned long __fastcall CAdrRecherche::RechercheSuivant( void )
{
int iCourant;
try {
    if (ulNumFicheResult == 0)
       return ulNumFicheResult;

    iCourant = slResult->IndexOf(ulNumFicheResult);
    if (iCourant+1 < slResult->Count)
       ulNumFicheResult = slResult->Strings[iCourant+1].ToInt();
    else
       ulNumFicheResult = 0;
    } catch( Exception &e ) {
        EICDisplayException( TAG(21), e );
        return 0;
    }
return ulNumFicheResult;
}

//---------------------------------------------------------------------------
// Une recherche a dû être faite précédemment
// Renvoi le nombre de fiche trouvée
unsigned int __fastcall CAdrRecherche::GetNbResult( void )
{
unsigned int unRetour = 0;
try {
    unRetour = slResult->Count;

    } catch( Exception &e ) {
        EICDisplayException( TAG(22), e );
        unRetour = 0;
    }
return unRetour;
}

//---------------------------------------------------------------------------
//---------------------------------Classe CAdr-------------------------------
//---------------------------------------------------------------------------
__fastcall CAdr::CAdr()
{
try {
    eFormatFiche = (TYPE_FORMAT) FORMAT_NON_DEFINI;
    pSignature   = NULL;

    //Handle vers la Dll et ses fonctions
    hCarnAdr               = NULL;
    _ChargerFiche          = NULL;
    _SauverFiche           = NULL;
    _NouvelleFiche         = NULL;
    _FctGereCarnet         = NULL;
    _SupprimerFiche        = NULL;
    _ConstituerDesignation = NULL;

    //Initialise les variables et structures
    Init();

    GetRepsCarnAdr(&aRepDll, NULL);
    aRepDll += "CarnAdr.dll";

    } catch(Exception &e) {
        EICDisplayException(TAG(100), e);
    }
}

//---------------------------------------------------------------------------
__fastcall CAdr::~CAdr()
{
try {
    FreeLibrary(hCarnAdr);
    hCarnAdr = NULL;
    } catch(Exception &e) {
        EICDisplayException(TAG(110), e);
    }
}

//---------------------------------------------------------------------------
//Initialise les variables et structures
void __fastcall CAdr::Init( void )
{
try {
    eFormatFiche = FORMAT_NON_DEFINI;

    InitContenuFiche();
    } catch( Exception &e ) {
        EICDisplayException( TAG(120), e );
    }
}

/*******************************************************************************
bool __fastcall NouvelleFicheVide()

Fonction : Créé une fiche vierge dans la table

*******************************************************************************/
void __fastcall CAdr::NouvelleFicheVide()
{
  try
  {
    if (!hCarnAdr)
       {
       hCarnAdr = LoadLibrary (aRepDll.c_str());
       if (!hCarnAdr)
          throw EAbort("Impossible de charger "+ aRepDll);
       }

    if (!_NouvelleFiche)
       {
       _NouvelleFiche = (FctNouvelleFiche) GetProcAddress(hCarnAdr, "_NouvelleFiche");
       if (!_NouvelleFiche)
          throw EAbort("Impossible de charger la fonction _NouvelleFiche");
       }
    InitContenuFiche();
    ulNumFiche = _NouvelleFiche();
    } catch( Exception &e ) {
        EICDisplayException( TAG(125), e );
    }
}
/*******************************************************************************
void __fastcall SupprimerFiche()

Fonction : Créé une fiche vierge dans la table

*******************************************************************************/
void __fastcall CAdr::SupprimerFiche()
{
try {
    if (!hCarnAdr)
       {
       hCarnAdr = LoadLibrary (aRepDll.c_str());
       if (!hCarnAdr)
          throw EAbort("Impossible de charger "+ aRepDll);
       }
    if (!_SupprimerFiche) {
        _SupprimerFiche = (FctSupprimerFiche) GetProcAddress(hCarnAdr, "_SupprimerFiche");
       if (!_SupprimerFiche)
            throw EAbort("Impossible de charger la fonction _SupprimerFiche");
    }

    _SupprimerFiche(ulNumFiche);

    } catch( Exception &e ) {
        EICDisplayException( TAG(126), e );
    }
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall CAdr::Assign(const CAdr &cSource)
{
try
   {
   aCategorie    = cSource.aCategorie    ;
   aTitre        = cSource.aTitre        ;
   aNom          = cSource.aNom          ;
   aPrenom       = cSource.aPrenom       ;
   aSociete      = cSource.aSociete      ;
   aFonction     = cSource.aFonction     ;
   aTelephone    = cSource.aTelephone    ;
   aTelecopie    = cSource.aTelecopie    ;
   aEMail        = cSource.aEMail        ;
   aSiteInternet = cSource.aSiteInternet ;
   aCommentaire  = cSource.aCommentaire  ;
   memcpy(&sRIB, &cSource.sRIB, sizeof(sRIB));
   pSignature->Assign( cSource.pSignature);
   sAdr0          = cSource.sAdr0         ;
   sAdr1          = cSource.sAdr1         ;
   sAdr2          = cSource.sAdr2         ;
   sAdr3          = cSource.sAdr3         ;
   sAdr4          = cSource.sAdr4         ;
   eFormatFiche   = cSource.eFormatFiche  ;
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(128), e);
   }
}

/*******************************************************************************
bool __fastcall Charge(unsigned long ulNum, TYPE_FORMAT Format = FORMAT_NON_DEFINI)

Fonction : Charge une fiche

P.E : ulNum : Numéro de la fiche à charger
      Format : Format auquel l'adresse doit être chargé. Si Format vaut FORMAT_NON_DEFINI,
               on conserve le format actuel

P.S : Retourne false si la fiche n'existe pas
*******************************************************************************/
bool __fastcall CAdr::Charge(unsigned long ulNum, TYPE_FORMAT Format)
{
bool bFicheTrouve = false;
TAdresseFormat1 sAdrTmp;
TInfosIndiv sInfosIndiv;

try {
    if (Format == FORMAT_NON_DEFINI)
       Format = eFormatFiche;
    eFormatFiche   = Format;

    if (ulNum == 0) //La fiche 0 ne peut pas exister => optimisation pour ne pas charger la library
       return false;

    if (!hCarnAdr)
       {
       hCarnAdr = LoadLibrary (aRepDll.c_str());
       if (!hCarnAdr)
          throw EAbort("Impossible de charger "+ aRepDll);
       }
    if (!_ChargerFiche) {
        _ChargerFiche = (FctChargerFiche) GetProcAddress(hCarnAdr, "_ChargerFiche");
        if (!_ChargerFiche)
            throw EAbort("Impossible de charger la fonction _ChargerFiche");
    }

    switch (Format) {
        case FORMAT_DETAILLE:
            bFicheTrouve = _ChargerFiche(Format, &sInfosIndiv, &sAdr0, ulNum);
            break;
        case FORMAT_1 :
            bFicheTrouve = _ChargerFiche(Format, &sInfosIndiv, &sAdr1, ulNum);
            break;
        case FORMAT_2 :
            bFicheTrouve = _ChargerFiche(Format, &sInfosIndiv, &sAdr2, ulNum);
            break;
        case FORMAT_3 :
            bFicheTrouve = _ChargerFiche(Format, &sInfosIndiv, &sAdr3, ulNum);
            break;
        case FORMAT_4 :
            bFicheTrouve = _ChargerFiche(Format, &sInfosIndiv, &sAdr4, ulNum);
            break;
        default : ASSERT(false); break;
    }
    if (bFicheTrouve)
		{
		aCategorie      = sInfosIndiv.szCategorie   ;
		aTitre          = sInfosIndiv.szTitre       ;
		aNom            = sInfosIndiv.szNom         ;
		aPrenom         = sInfosIndiv.szPrenom      ;
		aFonction       = sInfosIndiv.szFonction    ;
		aSociete        = sInfosIndiv.szSociete     ;
		aTelephone      = sInfosIndiv.szTelephone   ;
		aTelecopie      = sInfosIndiv.szTelecopie   ;
		aEMail          = sInfosIndiv.szEMail       ;
		aSiteInternet   = sInfosIndiv.szSiteInternet;
		aCommentaire    = sInfosIndiv.aCommentaire  ;
		memcpy(&sRIB, &sInfosIndiv.sRIB, sizeof(sRIB));

		if (sInfosIndiv.pSignature->Graphic)
			{
			pSignature->Assign( sInfosIndiv.pSignature);
			}

		ulNumFiche     = ulNum;
		}
    else
       InitContenuFiche();
	   
    } catch( Exception &e ) {
        EICDisplayException( TAG(130), e );
    }
return bFicheTrouve;
}

/*******************************************************************************
unsigned long __fastcall CAdr::Sauve( void )

Fonction : Sauvegarde la fiche

P.E :

P.E modifiés :

P.S :
*******************************************************************************/
unsigned long __fastcall CAdr::Sauve( void )
{
bool bFicheSauve = false;
TInfosIndiv sInfosIndiv;
try {
    if (!hCarnAdr)
       {
       hCarnAdr = LoadLibrary (aRepDll.c_str());
       if (!hCarnAdr)
          throw EAbort("Impossible de charger "+ aRepDll);
       }
    if (!_SauverFiche) {
        _SauverFiche = (FctSauverFiche) GetProcAddress(hCarnAdr, "_SauverFiche");
        if (!_SauverFiche)
            throw EAbort("Impossible de charger la fonction _SauverFiche");
    }

    //Si aucune fiche n'a été chargée on en créé une
    if (ulNumFiche == 0) {
        if (!_NouvelleFiche) {
            _NouvelleFiche = (FctNouvelleFiche) GetProcAddress(hCarnAdr, "_NouvelleFiche");
            if (!_NouvelleFiche)
                throw EAbort("Impossible de charger la fonction _NouvelleFiche");
        }
        ulNumFiche = _NouvelleFiche();
    }

    strncpy(sInfosIndiv.szCategorie   , aCategorie.c_str()   , NB_CAR_CATEG-1   );   sInfosIndiv.szCategorie   [NB_CAR_CATEG-1   ] = '\0';
    strncpy(sInfosIndiv.szTitre       , aTitre.c_str()       , NB_CAR_TITRE-1   );   sInfosIndiv.szTitre       [NB_CAR_TITRE-1   ] = '\0';
    strncpy(sInfosIndiv.szNom         , aNom.c_str()         , NB_CAR_NOM-1     );   sInfosIndiv.szNom         [NB_CAR_NOM-1     ] = '\0';
    strncpy(sInfosIndiv.szPrenom      , aPrenom.c_str()      , NB_CAR_PRENOM-1  );   sInfosIndiv.szPrenom      [NB_CAR_PRENOM-1  ] = '\0';
    strncpy(sInfosIndiv.szFonction    , aFonction.c_str()    , NB_CAR_FONCTION-1);   sInfosIndiv.szFonction    [NB_CAR_FONCTION-1] = '\0';
    strncpy(sInfosIndiv.szSociete     , aSociete.c_str()     , NB_CAR_SOCIETE-1 );   sInfosIndiv.szSociete     [NB_CAR_SOCIETE-1 ] = '\0';
    strncpy(sInfosIndiv.szTelephone   , aTelephone.c_str()   , NB_CAR_TEL-1     );   sInfosIndiv.szTelephone   [NB_CAR_TEL-1     ] = '\0';
    strncpy(sInfosIndiv.szTelecopie   , aTelecopie.c_str()   , NB_CAR_FAX-1     );   sInfosIndiv.szTelecopie   [NB_CAR_FAX-1     ] = '\0';
    strncpy(sInfosIndiv.szEMail       , aEMail.c_str()       , NB_CAR_EMAIL-1   );   sInfosIndiv.szEMail       [NB_CAR_EMAIL-1   ] = '\0';
    strncpy(sInfosIndiv.szSiteInternet, aSiteInternet.c_str(), NB_CAR_SITEWEB-1 );   sInfosIndiv.szSiteInternet[NB_CAR_SITEWEB-1 ] = '\0';
    sInfosIndiv.aCommentaire = aCommentaire;
    memcpy(&sInfosIndiv.sRIB, &sRIB, sizeof(sRIB));
    sInfosIndiv.pSignature->Assign(pSignature);

    switch (eFormatFiche) {
        case FORMAT_DETAILLE:
            bFicheSauve = _SauverFiche(eFormatFiche, &sInfosIndiv, &sAdr0, ulNumFiche);
            break;
        case FORMAT_1 :
            bFicheSauve = _SauverFiche(eFormatFiche, &sInfosIndiv, &sAdr1, ulNumFiche);
            break;
        case FORMAT_2 :
            bFicheSauve = _SauverFiche(eFormatFiche, &sInfosIndiv, &sAdr2, ulNumFiche);
            break;
        case FORMAT_3 :
             bFicheSauve = _SauverFiche(eFormatFiche, &sInfosIndiv, &sAdr3, ulNumFiche);
             break;
        case FORMAT_4 :
             bFicheSauve = _SauverFiche(eFormatFiche, &sInfosIndiv, &sAdr4, ulNumFiche);
             break;
        default : ASSERT(false);
           break;
      }

    } catch( Exception &e ) {
        EICDisplayException( TAG(140), e );
    }
    return bFicheSauve ? ulNumFiche : 0;
}

//------------------------------------------------------------------------------
//------Remplissage ou lecture des structures d'adresses par l'utilisateur------
//------------------------------------------------------------------------------
void __fastcall CAdr::SetAdr(const TAdresseDetaillee &_sAdr0)
{
try {
    ASSERT(eFormatFiche == FORMAT_NON_DEFINI || eFormatFiche == FORMAT_DETAILLE);

    if (eFormatFiche == FORMAT_NON_DEFINI)
       eFormatFiche = FORMAT_DETAILLE;

    sAdr0 = _sAdr0;

    } catch(Exception &e) {
        EICDisplayException(TAG(170), e);
    }
}

void __fastcall CAdr::SetAdr(const TAdresseFormat1 &_sAdr1)
{
try {
    ASSERT(eFormatFiche == FORMAT_NON_DEFINI || eFormatFiche == FORMAT_1);

    if (eFormatFiche == FORMAT_NON_DEFINI)
       eFormatFiche = FORMAT_1;

    sAdr1 = _sAdr1;

    } catch(Exception &e) {
        EICDisplayException(TAG(170), e);
    }
}

//---------------------------------------------------------------------------
void __fastcall CAdr::SetAdr(const TAdresseFormat2 &_sAdr2)
{
try {
    ASSERT(eFormatFiche == FORMAT_NON_DEFINI || eFormatFiche == FORMAT_2);

    if (eFormatFiche == FORMAT_NON_DEFINI)
       eFormatFiche = FORMAT_2;
    sAdr2 = _sAdr2;

    } catch(Exception &e) {
        EICDisplayException(TAG(180), e);
    }
}

//---------------------------------------------------------------------------
void __fastcall CAdr::SetAdr(const TAdresseFormat3 &_sAdr3)
{
try {
    ASSERT(eFormatFiche == FORMAT_NON_DEFINI || eFormatFiche == FORMAT_3);

    if (eFormatFiche == FORMAT_NON_DEFINI)
       eFormatFiche = FORMAT_3;

    sAdr3 = _sAdr3;

    } catch(Exception &e) {
        EICDisplayException(TAG(190), e);
    }
}

//---------------------------------------------------------------------------
void __fastcall CAdr::SetAdr(const TAdresseFormat4 &_sAdr4)
{
try {
    ASSERT(eFormatFiche == FORMAT_NON_DEFINI || eFormatFiche == FORMAT_4);

    if (eFormatFiche == FORMAT_NON_DEFINI)
       eFormatFiche = FORMAT_4;

    sAdr4 = _sAdr4;

    } catch(Exception &e) {
        EICDisplayException(TAG(200), e);
    }
}

//---------------------------------------------------------------------------
void __fastcall CAdr::GetAdr(TAdresseDetaillee *_sAdrCible) const
{
try {
    if (eFormatFiche == FORMAT_DETAILLE)
        *_sAdrCible = sAdr0;
    else
       ConvertirAdresse((void*) &sAdr0,
                        eFormatFiche,
                        (void*)_sAdrCible,
                        FORMAT_DETAILLE);
    } catch(Exception &e) {
        EICDisplayException(TAG(210), e);
    }
}
//---------------------------------------------------------------------------
void __fastcall CAdr::GetAdr(TAdresseFormat1 *_sAdrCible) const
{
try {
    if (eFormatFiche == FORMAT_1)
        *_sAdrCible = sAdr1;
    else
       ConvertirAdresse((void*) &sAdr1,
                        eFormatFiche,
                        (void*)_sAdrCible,
                        FORMAT_1);
    } catch(Exception &e) {
        EICDisplayException(TAG(210), e);
    }
}
//---------------------------------------------------------------------------
void __fastcall CAdr::GetAdr(TAdresseFormat2 *_sAdrCible) const
{
try {
    if (eFormatFiche == FORMAT_2)
        *_sAdrCible = sAdr2;
    else
       ConvertirAdresse((void*) &sAdr2,
                        eFormatFiche,
                        (void*)_sAdrCible,
                        FORMAT_2);
    } catch(Exception &e) {
        EICDisplayException(TAG(211), e);
    }
}
//---------------------------------------------------------------------------
void __fastcall CAdr::GetAdr(TAdresseFormat3 *_sAdrCible) const
{
try {
    if (eFormatFiche == FORMAT_3)
        *_sAdrCible = sAdr3;
    else
       ConvertirAdresse((void*) &sAdr3,
                        eFormatFiche,
                        (void*)_sAdrCible,
                        FORMAT_3);
    } catch(Exception &e) {
        EICDisplayException(TAG(212), e);
    }
}
//---------------------------------------------------------------------------
void __fastcall CAdr::GetAdr(TAdresseFormat4 *_sAdrCible) const
{
try {
    if (eFormatFiche == FORMAT_4)
        *_sAdrCible = sAdr4;
    else
       ConvertirAdresse((void*) &sAdr4,
                        eFormatFiche,
                        (void*)_sAdrCible,
                        FORMAT_4);
    } catch(Exception &e) {
        EICDisplayException(TAG(213), e);
    }
}
/*******************************************************************************
Prototype :
  bool  __fastcall SelectUneFiche (TYPE_FORMAT Format = FORMAT_NON_DEFINI,
                                   const AnsiString &aCategoriesAAfficher = EmptyStr,
                                   const AnsiString &aCategorieParDefaut = EmptyStr);

Fonction : Ouvre le carnet d'adresses pour la sélection d'une fiche.

P.E : Format : Format de l'adresse désirée. S'il vaut : FORMAT_NON_DEFINI, le format
               actuel est conservé.
      aCategoriesAAfficher : Liste de catégories sélectionnables,
                             séparées pars des virgules. Si vide, toutes les
                             catégories sont visibles.
      aCategorieParDefaut : Catégorie sélectionnée par défaut;

P.S : retourne false si la fiche n'a pas changée

*******************************************************************************/
bool  __fastcall CAdr::SelectUneFiche(TYPE_FORMAT Format,
                                      const AnsiString &aCategoriesAAfficher,
                                      const AnsiString &aCategorieParDefaut)
	{
   unsigned long FichePrec;
   unsigned long FicheSelect;

	try
		{
      FichePrec = ulNumFiche;
      FicheSelect = ::SelectUneFiche(ulNumFiche,
                                     aCategoriesAAfficher,
                                     aCategorieParDefaut);
      //SI aucune fiche n'a été choisie
      if(!FicheSelect)
         {
         //Si la fiche courante a été supprimée
         if (!Charge(ulNumFiche, (Format==FORMAT_NON_DEFINI)?eFormatFiche:Format))
            InitContenuFiche();
         }
      else
         //On recharge toujours car la fiche a pu être modifiée
         Charge(FicheSelect, (Format==FORMAT_NON_DEFINI)?eFormatFiche:Format);
		}
	catch( Exception &e )
		{
		EICDisplayException(TAG(222), e);
		}

	return (ulNumFiche != FichePrec);
	}
/*******************************************************************************
unsigned long __fastcall GetNumFiche();

Fonction :

P.E :

P.E modifiés :

P.S :
*******************************************************************************/
unsigned long __fastcall CAdr::GetNumFiche() const
{
return ulNumFiche;
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
AnsiString __fastcall CAdr::GetDesignation() const
{
char szDesignation[3*60+40] = "";
HINSTANCE hCarnAdrInterneFct = NULL;                        //  Permet de pouvoir
TFctConstituerDesignation _ConstituerDesignationInterneFct; //  déclarer la fonction
bool bLoadLibraryInterne = false;;                          //  en const
try
   {
   hCarnAdrInterneFct = hCarnAdr;
   if (!hCarnAdrInterneFct)
      {
      hCarnAdrInterneFct = LoadLibrary (aRepDll.c_str());
      if (!hCarnAdrInterneFct)
         throw EAbort("Impossible de charger "+ aRepDll);
      bLoadLibraryInterne = true;
      }
   _ConstituerDesignationInterneFct = _ConstituerDesignation;
   if (!_ConstituerDesignationInterneFct)
      {
      _ConstituerDesignationInterneFct = (TFctConstituerDesignation) GetProcAddress(hCarnAdrInterneFct, "_ConstituerDesignation");
      if (!_ConstituerDesignationInterneFct)
          throw EAbort("Impossible de charger la fonction _ConstituerDesignation");
      }

   _ConstituerDesignationInterneFct(aSociete.c_str(), aTitre.c_str(), aNom.c_str(), aPrenom.c_str(), aFonction.c_str(), aCommentaire.c_str(),
                                    szDesignation);

   if (bLoadLibraryInterne)
      FreeLibrary(hCarnAdrInterneFct);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(235), e);
   }
return AnsiString(szDesignation);
}

/*******************************************************************************
void __fastcall CAdr::InitContenuFiche()

Fonction : Réinitialise la fiche excepté son TYPE_FORMAT

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall CAdr::InitContenuFiche()
{
try {
    ulNumFiche      = 0;

    //Structure sur les infos diverses
    aCategorie      = EmptyStr;
    aTitre          = EmptyStr;
    aNom            = EmptyStr;
    aPrenom         = EmptyStr;
    aFonction       = EmptyStr;
    aSociete        = EmptyStr;
    aTelephone      = EmptyStr;
    aTelecopie      = EmptyStr;
    aEMail          = EmptyStr;
    aSiteInternet   = EmptyStr;
    aCommentaire    = EmptyStr;
    memset(&sRIB, 0, sizeof(sRIB));

	pSignature = NULL;
    pSignature      = new TPicture;

    //Init des valeurs pour les classes d'adresses
    sAdr0.szNumero[0]       = '\0';
    sAdr0.szBis[0]          = '\0';
    sAdr0.szTypeVoie[0]     = '\0';
    sAdr0.szLibelleVoie[0]  = '\0';
    sAdr0.szBatiment[0]     = '\0';
    sAdr0.szEscalier[0]     = '\0';
    sAdr0.szEtage[0]        = '\0';
    sAdr0.szNumLot[0]       = '\0';
    sAdr0.szLieuDit[0]      = '\0';
    sAdr0.szComplement[0]   = '\0';
    sAdr0.szBoitePostale[0] = '\0';
    sAdr0.szCodePostal[0]   = '\0';
    sAdr0.szVille[0]        = '\0';
    sAdr0.szCedex[0]        = '\0';
    sAdr0.nPays             = 0;

    sAdr1.aAdresseLigne1    = EmptyStr;
    sAdr1.aAdresseLigne2    = EmptyStr;
    sAdr1.aAdresseLigne3    = EmptyStr;
    sAdr1.aCodePostal       = EmptyStr;
    sAdr1.aVille            = EmptyStr;

    sAdr2.aLieuDit          = EmptyStr;
    sAdr2.aNum              = EmptyStr;
    sAdr2.aNature           = EmptyStr;
    sAdr2.aNomVoie          = EmptyStr;
    sAdr2.aComplement       = EmptyStr;
    sAdr2.aCodePostal       = EmptyStr;
    sAdr2.aVille            = EmptyStr;

    sAdr3.aResidence  = EmptyStr;
    sAdr3.aBatiment   = EmptyStr;
    sAdr3.aEscalier   = EmptyStr;
    sAdr3.aEtage      = EmptyStr;
    sAdr3.aNumLot     = EmptyStr;
    sAdr3.aAdresse    = EmptyStr;
    sAdr3.aCodePostal = EmptyStr;
    sAdr3.aVille      = EmptyStr;

    sAdr4.aLieuDit    = EmptyStr;
    sAdr4.aNum        = EmptyStr;
    sAdr4.aNature     = EmptyStr;
    sAdr4.aNomVoie    = EmptyStr;
    sAdr4.aBP         = EmptyStr;
    sAdr4.aComplement = EmptyStr;
    sAdr4.aCodePostal = EmptyStr;
    sAdr4.aVille      = EmptyStr;

    } catch( Exception &e ) {
        EICDisplayException( TAG(240), e );
    }
}

/*******************************************************************************
bool __fastcall CAdr::ConvertirAdresse(void *sAdresseSource,
                                       TYPE_FORMAT FormatSource,
                                       void *sAdresseCible,
                                       TYPE_FORMAT FormatCible) const

Fonction :

Paramètres d'entrée :

Paramètres modifiés :

Valeur retournée :
*******************************************************************************/
void __fastcall CAdr::ConvertirAdresse(void *sAdresseSource,
                                       TYPE_FORMAT FormatSource,
                                       void *sAdresseCible,
                                       TYPE_FORMAT FormatCible) const
{
HINSTANCE hCarnAdr = NULL;
TFctConvertirAdresse _ConvertirAdresse = NULL;;

try {
    hCarnAdr = LoadLibrary (aRepDll.c_str());
    if (!hCarnAdr)
       throw EAbort("Impossible de charger "+ aRepDll);

    _ConvertirAdresse = (TFctConvertirAdresse) GetProcAddress(hCarnAdr, "_ConvertirAdresse");
    if (!_ConvertirAdresse)
       throw EAbort("Impossible de charger la fonction _ConvertirAdresse");

    _ConvertirAdresse(sAdresseSource,
                      FormatSource,
                      sAdresseCible,
                      FormatCible);
    }
catch( Exception &e )
   {
   EICDisplayException( TAG(250), e );
   }
FreeLibrary(hCarnAdr);   hCarnAdr = NULL;
}

//---------------------------------------------------------------------------
//------------------------------Classe CAdrPanel-----------------------------
//---------------------------------------------------------------------------


//---------------------------------------------------------------------------
//------------------------------Methodes public------------------------------
//---------------------------------------------------------------------------
__fastcall CAdrPanel::CAdrPanel(TComponent* Owner)
  :CAdressePanel(Owner)
{
try {
    if (!ComponentState.Contains(csDesigning))
       Adr = new CAdr;
    else
       Adr = NULL;
    } catch(Exception &e) {
        EICDisplayException(TAG(1000), e);
    }
}

//----------------------------------------------------------------------------
__fastcall CAdrPanel::~CAdrPanel()
{
try
   {
   delete Adr;        Adr = NULL;
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(1010), e);
   }
}
//---------------------------------------------------------------------------
void __fastcall CAdrPanel::Afficher(int nNumFiche)
{
try {
    if (!ComponentState.Contains(csDesigning)) {
        Adr->Init();
        if (Adr->Charge(nNumFiche,inherited::TypeFormat))
            {
            switch (inherited::TypeFormat) {
              case  FORMAT_1 :  ASSERT(inherited::TypeFormat == FORMAT_1);
                                if (!ComponentState.Contains(csDesigning)) {
                                    TAdresseFormat1 _sAdr1;
                                    Adr->GetAdr(&_sAdr1);
                                    inherited::RemplirPanel(_sAdr1);
                                }
                                break;
              case  FORMAT_2 :  ASSERT(inherited::TypeFormat == FORMAT_2);
                                if (!ComponentState.Contains(csDesigning)) {
                                    TAdresseFormat2 _sAdr2;
                                    Adr->GetAdr(&_sAdr2);
                                    inherited::RemplirPanel(_sAdr2);
                                }
                                break;
              case  FORMAT_3:   ASSERT(inherited::TypeFormat == FORMAT_3);
                                if (!ComponentState.Contains(csDesigning)) {
                                    TAdresseFormat3 _sAdr3;
                                    Adr->GetAdr(&_sAdr3);
                                    inherited::RemplirPanel(_sAdr3);
                                }
                                break;
              case  FORMAT_4 :  ASSERT(inherited::TypeFormat == FORMAT_4);
                                if (!ComponentState.Contains(csDesigning)) {
                                    TAdresseFormat4 _sAdr4;
                                    Adr->GetAdr(&_sAdr4);
                                    inherited::RemplirPanel(_sAdr4);
                                }
                                break;
              default: ASSERT(false);
            }

            Categorie       = Adr->aCategorie;
            Titre           = Adr->aTitre;
            Nom             = Adr->aNom;
            Prenom          = Adr->aPrenom;
            Fonction        = Adr->aFonction;
            Societe         = Adr->aSociete;
            Telephone       = Adr->aTelephone;
            Telecopie       = Adr->aTelecopie;
            EMail           = Adr->aEMail;
            SiteInternet    = Adr->aSiteInternet;
            Commentaire     = Adr->aCommentaire;
            memcpy(&m_sInfosIndiv.sRIB, &Adr->sRIB, sizeof(m_sInfosIndiv.sRIB));
            m_sInfosIndiv.pSignature->Assign(Adr->pSignature);
            }
        }

    } catch( Exception &e ) {
        EICDisplayException( TAG(1020), e );
    }
}

//---------------------------------------------------------------------------
unsigned long  __fastcall CAdrPanel::Enregistrer( void )
{
try {
    if (!ComponentState.Contains(csDesigning)) {
        Adr->aCategorie     = Categorie;
        Adr->aTitre         = Titre;
        Adr->aNom           = Nom;
        Adr->aPrenom        = Prenom;
        Adr->aFonction      = Fonction;
        Adr->aSociete       = Societe;
        Adr->aTelephone     = Telephone;
        Adr->aTelecopie     = Telecopie;
        Adr->aEMail         = EMail;
        Adr->aSiteInternet  = SiteInternet;
        Adr->aCommentaire   = Commentaire;
        memcpy(&Adr->sRIB, &m_sInfosIndiv.sRIB, sizeof(m_sInfosIndiv.sRIB));
        Adr->pSignature->Assign(m_sInfosIndiv.pSignature);

        switch (inherited::TypeFormat) {
          case  FORMAT_1 :  ASSERT(inherited::TypeFormat == FORMAT_1);
                            if (!ComponentState.Contains(csDesigning)) {
                                TAdresseFormat1 _sAdr1;
                                LirePanel(&_sAdr1);
                                Adr->SetAdr(_sAdr1);
                            }
                            break;
          case  FORMAT_2 :  ASSERT(inherited::TypeFormat == FORMAT_2);
                            if (!ComponentState.Contains(csDesigning)) {
                                TAdresseFormat2 _sAdr2;
                                LirePanel(&_sAdr2);
                                Adr->SetAdr(_sAdr2);

                            }
                            break;
          case  FORMAT_3:   ASSERT(inherited::TypeFormat == FORMAT_3);
                            if (!ComponentState.Contains(csDesigning)) {
                                TAdresseFormat3 _sAdr3;
                                LirePanel(&_sAdr3);
                                Adr->SetAdr(_sAdr3);
                            }
                            break;
          case  FORMAT_4 :  ASSERT(inherited::TypeFormat == FORMAT_4);
                            if (!ComponentState.Contains(csDesigning)) {
                                TAdresseFormat4 _sAdr4;
                                LirePanel(&_sAdr4);
                                Adr->SetAdr(_sAdr4);
                            }
                            break;
          default: ASSERT(false);
        }

        if (Adr->Sauve())
            return Adr->GetNumFiche();
    }
        return 0;
    } catch( Exception &e ) {
        EICDisplayException( TAG(1030), e );
        return 0;
    }
}

/*******************************************************************************
unsigned long  __fastcall Nouveau();

Fonction :

P.E :

P.E modifiés :

P.S :
*******************************************************************************/
unsigned long  __fastcall CAdrPanel::Nouveau()
{
try
   {
   Adr->NouvelleFicheVide();
   Afficher(Adr->GetNumFiche()); //Affiche la fiche qui vient d'être crée
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(1035), e);
   }
return Adr->GetNumFiche();
}


void __fastcall CAdrPanel::Vider()
{
try {
    if (!ComponentState.Contains(csDesigning))
        Adr->Init();

    Categorie       = "";
    Titre           = "";
    Nom             = "";
    Prenom          = "";
    Societe         = "";
    Telephone       = "";
    Telecopie       = "";
    EMail           = "";
    SiteInternet    = "";
    Commentaire     = "";
    inherited::Vider();
    } catch( Exception &e ) {
        EICDisplayException( TAG(1040), e );
    }
}

//---------------------------------------------------------------------------
//-----------------------------Fonctions internes----------------------------
//---------------------------------------------------------------------------
void __fastcall CAdrPanel::SetTypeFormat( TYPE_FORMAT f )
{
int i;
try {
     if (f != FORMAT_TDFC)
       inherited::TypeFormat = f;

    } catch(Exception &e) {
        EICDisplayException(TAG(1060), e);
    }
}

//---------------------------------------------------------------------------
TYPE_FORMAT __fastcall CAdrPanel::GetTypeFormat()
{
TYPE_FORMAT f;
try {
      f = inherited::TypeFormat;
    } catch( Exception &e ) {
        EICDisplayException( TAG(1070), e );
    }
    return f;
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
AnsiString __fastcall CAdrPanel::GetDesignation()
{
return Adr->aDesignation;
}

AnsiString __fastcall CAdrPanel::GetCategorie() const
{
return AnsiString(m_sInfosIndiv.szCategorie);
}
void __fastcall CAdrPanel::SetCategorie(const AnsiString aCategorie)
{
ASSERT(aCategorie.Length() < NB_CAR_CATEG);
strncpy(m_sInfosIndiv.szCategorie, aCategorie.c_str(), NB_CAR_CATEG-1);
}

AnsiString __fastcall CAdrPanel::GetTitre() const
{
return AnsiString(m_sInfosIndiv.szTitre);
}
void __fastcall CAdrPanel::SetTitre(const AnsiString aTitre)
{
ASSERT(aTitre.Length() < NB_CAR_TITRE);
strncpy(m_sInfosIndiv.szTitre, aTitre.c_str(), NB_CAR_TITRE-1);
}

AnsiString __fastcall CAdrPanel::GetNom() const
{
return AnsiString(m_sInfosIndiv.szNom);
}
void __fastcall CAdrPanel::SetNom(const AnsiString aNom)
{
ASSERT(aNom.Length() < NB_CAR_NOM);
strncpy(m_sInfosIndiv.szNom, aNom.c_str(), NB_CAR_NOM-1);
}

AnsiString __fastcall CAdrPanel::GetPrenom() const
{
return AnsiString(m_sInfosIndiv.szPrenom);
}
void __fastcall CAdrPanel::SetPrenom(const AnsiString aPrenom)
{
ASSERT(aPrenom.Length() < NB_CAR_PRENOM);
strncpy(m_sInfosIndiv.szPrenom, aPrenom.c_str(), NB_CAR_PRENOM-1);
}

AnsiString __fastcall CAdrPanel::GetFonction() const
{
return AnsiString(m_sInfosIndiv.szFonction);
}
void __fastcall CAdrPanel::SetFonction(const AnsiString aFonction)
{
ASSERT(aFonction.Length() < NB_CAR_FONCTION);
strncpy(m_sInfosIndiv.szFonction, aFonction.c_str(), NB_CAR_FONCTION-1);
}

AnsiString __fastcall CAdrPanel::GetSociete() const
{
return AnsiString(m_sInfosIndiv.szSociete);
}
void __fastcall CAdrPanel::SetSociete(const AnsiString aSociete)
{
ASSERT(aSociete.Length() < NB_CAR_SOCIETE);
strncpy(m_sInfosIndiv.szSociete, aSociete.c_str(), NB_CAR_SOCIETE-1);
}

AnsiString __fastcall CAdrPanel::GetTelephone() const
{
return AnsiString(m_sInfosIndiv.szTelephone);
}
void __fastcall CAdrPanel::SetTelephone(const AnsiString aTelephone)
{
ASSERT(aTelephone.Length() < NB_CAR_TEL);
strncpy(m_sInfosIndiv.szTelephone, aTelephone.c_str(), NB_CAR_TEL-1);
}

AnsiString __fastcall CAdrPanel::GetTelecopie() const
{
return AnsiString(m_sInfosIndiv.szTelecopie);
}
void __fastcall CAdrPanel::SetTelecopie(const AnsiString aTelecopie)
{
ASSERT(aTelecopie.Length() < NB_CAR_FAX);
strncpy(m_sInfosIndiv.szTelecopie, aTelecopie.c_str(), NB_CAR_FAX-1);
}

AnsiString __fastcall CAdrPanel::GetEMail() const
{
return AnsiString(m_sInfosIndiv.szEMail);
}
void __fastcall CAdrPanel::SetEMail(const AnsiString aEMail)
{
ASSERT(aEMail.Length() < NB_CAR_EMAIL);
strncpy(m_sInfosIndiv.szEMail, aEMail.c_str(), NB_CAR_EMAIL-1);
}

AnsiString __fastcall CAdrPanel::GetSiteInternet() const
{
return AnsiString(m_sInfosIndiv.szSiteInternet);
}
void __fastcall CAdrPanel::SetSiteInternet(const AnsiString aSiteInternet)
{
ASSERT(aSiteInternet.Length() < NB_CAR_SITEWEB);
strncpy(m_sInfosIndiv.szSiteInternet, aSiteInternet.c_str(), NB_CAR_SITEWEB-1);
}

AnsiString __fastcall CAdrPanel::GetRIBDesignation() const
{
return AnsiString(m_sInfosIndiv.sRIB.szDesign);
}

void __fastcall CAdrPanel::SetRIBDesignation(AnsiString aDesignation)
{
ASSERT(aDesignation.Length() < NB_CAR_RIB_DESIGNATION);
strncpy(m_sInfosIndiv.sRIB.szDesign, aDesignation.c_str(), NB_CAR_RIB_DESIGNATION-1);
}

AnsiString __fastcall CAdrPanel::GetRIBBanque() const
{
return AnsiString(m_sInfosIndiv.sRIB.szBanque);
}

void __fastcall CAdrPanel::SetRIBBanque(AnsiString aBanque)
{
ASSERT(aBanque.Length() < NB_CAR_RIB_BANQUE);
strncpy(m_sInfosIndiv.sRIB.szBanque, aBanque.c_str(), NB_CAR_RIB_BANQUE-1);
}

AnsiString __fastcall CAdrPanel::GetRIBGuichet() const
{
return AnsiString(m_sInfosIndiv.sRIB.szGuichet);
}

void __fastcall CAdrPanel::SetRIBGuichet(AnsiString aGuichet)
{
ASSERT(aGuichet.Length() < NB_CAR_RIB_GUICHET);
strncpy(m_sInfosIndiv.sRIB.szGuichet, aGuichet.c_str(), NB_CAR_RIB_GUICHET-1);
}

AnsiString __fastcall CAdrPanel::GetRIBCompte() const
{
return AnsiString(m_sInfosIndiv.sRIB.szCompte);
}

void __fastcall CAdrPanel::SetRIBCompte(AnsiString aCompte)
{
ASSERT(aCompte.Length() < NB_CAR_RIB_COMPTE);
strncpy(m_sInfosIndiv.sRIB.szCompte, aCompte.c_str(), NB_CAR_RIB_COMPTE-1);
}

AnsiString __fastcall CAdrPanel::GetRIBCle() const
{
return AnsiString(m_sInfosIndiv.sRIB.szCle);
}

void __fastcall CAdrPanel::SetRIBCle(AnsiString aCle)
{
ASSERT(aCle.Length() < NB_CAR_RIB_CLE);
strncpy(m_sInfosIndiv.sRIB.szCle, aCle.c_str(), NB_CAR_RIB_CLE-1);
}

TPicture* __fastcall CAdrPanel::GetSignature()
{
return m_sInfosIndiv.pSignature;
}

void __fastcall CAdrPanel::SetSignature(TPicture *_pSignature)
{
ASSERT(_pSignature);
m_sInfosIndiv.pSignature->Assign(_pSignature);
}

